面向对象进阶
一、面向对象三大特性
封装：隐藏实现细节，仅对外暴露访问接口（私有属性/property实现）
继承：子类复用父类代码，增量扩展新功能
多态：同一个方法，不同对象执行不同实现（必须继承+方法重写）
二、继承
1.基础语法
class 子类(父类1,父类2...): #多继承 pass
无指定父类，默认继承
object（所有类顶层父类）子类不重写
__init：自动调用父类构造；重写__init，不会自动调用父构造，需手动
#两种调用父类构造 #1.父类名.__init(self,参数) Person.__init__(self,name,age) #2.super()推荐 super().__init__(name,age)
2.成员继承与重写
继承：除构造方法外所有属性、方法（含私有）均可继承
方法重写：子类定义和父类同名方法，覆盖父类实现
class Person:
def say(self):
print("人说话")
class Student(Person):
def say(self): #重写
print("学生发言")3.MRO查找顺序
类.mro() / 类.__mro__查看继承查找顺序，多继承从左向右找方法
class C(B,A): print(C.mro())
4.多重继承
一个子类多个父，代码冗余时慎用，同名方法靠左优先
5.super()
super代表父类定义，不是父类对象，自动遵循MRO顺序查找
super().方法名()
6.__str__重写
print(对象)、str(对象)自动调用__str__，用于自定义对象描述
class Person:
def __init__(self,name):
self.name=name
def __str__(self):
return f"姓名：{self.name}"三、多态
条件：继承 + 方法重写
核心：同一个函数接收不同子类对象，执行各自重写的方法
class Animal:
def shout(self):pass
class Dog(Animal):
def shout(self):print("汪汪")
class Cat(Animal):
def shout(self):print("喵喵")
def func(ani):
ani.shout()
func(Dog())
func(Cat())四、运算符重载（特殊魔法方法）
运算符本质调用对应双下划线方法，重写即重载
| 运算符 | 对应方法 |
|---|---|
| + | __add__ |
| * | __mul__ |
| == | __eq__ |
class Person:
def __init__(self,name):
self.name=name
def __add__(self,other):
return self.name+other.name
p1=Person("张三")
p2=Person("李四")
print(p1+p2)常用特殊方法：__init__构造、__del__析构、__str__字符串、__call__对象当函数调用
五、常用特殊属性
obj.__dict__ #实例属性字典 obj.__class__ #对象所属类 类.__bases__ #父类元组 类.__mro__ #继承列表 类.__subclasses__() #所有子类
六、浅拷贝&深拷贝
import copy
浅拷贝copy.copy()：创建新外层对象，子对象共用引用，修改子对象原数据同步变
深拷贝copy.deepcopy()：递归拷贝所有层级子对象，完全独立互不影响
七、组合（has-a，代码复用）
is-a → 用继承（狗是动物）
has-a → 用组合（手机拥有CPU，把对象当做属性）
class Cpu:pass class Phone: def __init__(self,c): self.cpu = c #组合
八、两种常用设计模式
1.工厂模式
专门工厂类负责创建对象，创建与使用分离
class Factory: def create_car(self,brand): if brand=="宝马":return BMW()
2.单例模式
一个类只创建1个实例，重写__new__控制对象创建
class Single: __obj=None def __new__(cls,*args): if not cls.__obj: cls.__obj=object.__new__(cls) return cls.__obj
九、课后四道作业（原题+完整代码）
作业1：深浅拷贝
题目：定义MobilePhone、CPU、Screen，创建对象，分别引用赋值、浅拷贝、深拷贝，标注内存关系
import copy
class CPU:
def calculate(self):
print("CPU计算",id(self))
class Screen:
def show(self):
print("屏幕显示",id(self))
c = CPU()
s = Screen()
m = MobilePhone(c,s)
n = m #引用：同一个对象
m2 = copy.copy(m) #浅：手机新对象，cpu/screen共用
m3 = copy.deepcopy(m) #深：全部新对象
m.calculate()
m2.calculate()
m3.calculate()内存说明：
n=m：同一地址，无新对象
copy：m/m2地址不同，cpu、screen地址完全相同
deepcopy：m/m3、cpu、screen全是新内存地址
作业2：组合实现汽车类
题目：发动机Motor、底盘Chassis、座椅Seat；汽车Car组合三个类，run调用各自work()
class Motor:
def work(self):
print("发动机运转")
class Chassis:
def work(self):
print("底盘工作")
class Seat:
def work(self):
print("座椅就绪")
class Car:
def __init__(self,m,c,s):
self.motor = m
self.chassis = c
self.seat = s
def run(self):
self.motor.work()
self.chassis.work()
self.seat()
#调用
car = Car(Motor(),Chassis(),Seat())
car.run()作业3：单例+工厂造电脑
题目：工厂单例，生产联想/华硕/神舟，Computer父类，各品牌重写calculate()
class Computer:
def calculate(self):
pass
class Lenovo(Computer):
def calculate(self):
print("联想电脑运算")
class Asus(Computer):
def calculate(self):
print("华硕电脑运算")
class Shenzhou(Computer):
def calculate(self):
print("神舟电脑运算")
#单例工厂
class CompFactory:
__obj = None
def __new__(cls):
if not cls.__obj:
cls.__obj = object.__new__(cls)
return cls.__obj
def create(self,name):
if name=="联想":
return Lenovo()
elif name=="华硕":
return Asus()
elif name=="神舟":
return Shenzhou()
#测试
fac = CompFactory()
pc = fac("联想")
pc.calculate()
fac2=CompFactory()
print(id(fac),id(fac2)) #地址一致，单例作业4：Employee雇员类
需求
属性id(自增从1001，起始1000)、name、salary
+重载：两个实例相加返回薪资总和@property管控salary：1000~50000
class Employee:
__auto_id = 1000 #全局自增基数
def __init__(self,name,salary):
Employee.__auto_id +=1
self.id = Employee.__auto_id
self.name = name
self.__salary = salary
@property
def salary(self):
return self.__salary
@salary.setter
def salary(self,val):
if 1000<=val<=50000:
self.__salary = val
else:
print("薪资范围错误")
#重载+
def __add__(self,other):
return self.salary + other.salary
#测试
e1=Employee("张三",3000)
e2=Employee("李四",5000)
print(e1+e2)
e1.salary=60000 #报错提示上一篇：暂无数据
下一篇：python基础概念
